require('./powerange.css');
( function() {

  /**
   * Require the given path.
   *
   * @param {String} path
   * @return {Object} exports
   * @api public
   */

  function require( path, parent, orig ) {
    var resolved = require.resolve( path );

    // lookup failed
    if ( null == resolved ) {
      orig = orig || path;
      parent = parent || 'root';
      var err = new Error( 'Failed to require "' + orig + '" from "' + parent + '"' );
      err.path = orig;
      err.parent = parent;
      err.require = true;
      throw err;
    }

    var module = require.modules[ resolved ];

    // perform real require()
    // by invoking the module's
    // registered function
    if ( !module._resolving && !module.exports ) {
      var mod = {};
      mod.exports = {};
      mod.client = mod.component = true;
      module._resolving = true;
      module.call( this, mod.exports, require.relative( resolved ), mod );
      delete module._resolving;
      module.exports = mod.exports;
    }

    return module.exports;
  }

  /**
   * Registered modules.
   */

  require.modules = {};

  /**
   * Registered aliases.
   */

  require.aliases = {};

  /**
   * Resolve `path`.
   *
   * Lookup:
   *
   *   - PATH/index.js
   *   - PATH.js
   *   - PATH
   *
   * @param {String} path
   * @return {String} path or null
   * @api private
   */

  require.resolve = function( path ) {
    if ( path.charAt( 0 ) === '/' ) path = path.slice( 1 );

    var paths = [
      path,
      path + '.js',
      path + '.json',
      path + '/index.js',
      path + '/index.json'
    ];

    for ( var i = 0; i < paths.length; i++ ) {
      var path = paths[ i ];
      if ( require.modules.hasOwnProperty( path ) ) return path;
      if ( require.aliases.hasOwnProperty( path ) ) return require.aliases[ path ];
    }
  };

  /**
   * Normalize `path` relative to the current path.
   *
   * @param {String} curr
   * @param {String} path
   * @return {String}
   * @api private
   */

  require.normalize = function( curr, path ) {
    var segs = [];

    if ( '.' != path.charAt( 0 ) ) return path;

    curr = curr.split( '/' );
    path = path.split( '/' );

    for ( var i = 0; i < path.length; ++i ) {
      if ( '..' == path[ i ] ) {
        curr.pop();
      } else if ( '.' != path[ i ] && '' != path[ i ] ) {
        segs.push( path[ i ] );
      }
    }

    return curr.concat( segs ).join( '/' );
  };

  /**
   * Register module at `path` with callback `definition`.
   *
   * @param {String} path
   * @param {Function} definition
   * @api private
   */

  require.register = function( path, definition ) {
    require.modules[ path ] = definition;
  };

  /**
   * Alias a module definition.
   *
   * @param {String} from
   * @param {String} to
   * @api private
   */

  require.alias = function( from, to ) {
    if ( !require.modules.hasOwnProperty( from ) ) {
      throw new Error( 'Failed to alias "' + from + '", it does not exist' );
    }
    require.aliases[ to ] = from;
  };

  /**
   * Return a require function relative to the `parent` path.
   *
   * @param {String} parent
   * @return {Function}
   * @api private
   */

  require.relative = function( parent ) {
    var p = require.normalize( parent, '..' );

    /**
     * lastIndexOf helper.
     */

    function lastIndexOf( arr, obj ) {
      var i = arr.length;
      while ( i-- ) {
        if ( arr[ i ] === obj ) return i;
      }
      return -1;
    }

    /**
     * The relative require() itself.
     */

    function localRequire( path ) {
      var resolved = localRequire.resolve( path );
      return require( resolved, parent, path );
    }

    /**
     * Resolve relative to the parent.
     */

    localRequire.resolve = function( path ) {
      var c = path.charAt( 0 );
      if ( '/' == c ) return path.slice( 1 );
      if ( '.' == c ) return require.normalize( p, path );

      // resolve deps by returning
      // the dep in the nearest "deps"
      // directory
      var segs = parent.split( '/' );
      var i = lastIndexOf( segs, 'deps' ) + 1;
      if ( !i ) i = 0;
      path = segs.slice( 0, i + 1 ).join( '/' ) + '/deps/' + path;
      return path;
    };

    /**
     * Check if module is defined at `path`.
     */

    localRequire.exists = function( path ) {
      return require.modules.hasOwnProperty( localRequire.resolve( path ) );
    };

    return localRequire;
  };
  require.register( "component-event/index.js", function( exports, require, module ) {
    var bind = window.addEventListener ? 'addEventListener' : 'attachEvent',
      unbind = window.removeEventListener ? 'removeEventListener' : 'detachEvent',
      prefix = bind !== 'addEventListener' ? 'on' : '';

    /**
     * Bind `el` event `type` to `fn`.
     *
     * @param {Element} el
     * @param {String} type
     * @param {Function} fn
     * @param {Boolean} capture
     * @return {Function}
     * @api public
     */

    exports.bind = function( el, type, fn, capture ) {
      el[ bind ]( prefix + type, fn, capture || false );
      return fn;
    };

    /**
     * Unbind `el` event `type`'s callback `fn`.
     *
     * @param {Element} el
     * @param {String} type
     * @param {Function} fn
     * @param {Boolean} capture
     * @return {Function}
     * @api public
     */

    exports.unbind = function( el, type, fn, capture ) {
      el[ unbind ]( prefix + type, fn, capture || false );
      return fn;
    };
  } );
  require.register( "component-query/index.js", function( exports, require, module ) {
    function one( selector, el ) {
      return el.querySelector( selector );
    }

    exports = module.exports = function( selector, el ) {
      el = el || document;
      return one( selector, el );
    };

    exports.all = function( selector, el ) {
      el = el || document;
      return el.querySelectorAll( selector );
    };

    exports.engine = function( obj ) {
      if ( !obj.one ) throw new Error( '.one callback required' );
      if ( !obj.all ) throw new Error( '.all callback required' );
      one = obj.one;
      exports.all = obj.all;
      return exports;
    };

  } );
  require.register( "component-matches-selector/index.js", function( exports, require, module ) {
    /**
     * Module dependencies.
     */

    var query = require( 'query' );

    /**
     * Element prototype.
     */

    var proto = Element.prototype;

    /**
     * Vendor function.
     */

    var vendor = proto.matches ||
      proto.webkitMatchesSelector ||
      proto.mozMatchesSelector ||
      proto.msMatchesSelector ||
      proto.oMatchesSelector;

    /**
     * Expose `match()`.
     */

    module.exports = match;

    /**
     * Match `el` to `selector`.
     *
     * @param {Element} el
     * @param {String} selector
     * @return {Boolean}
     * @api public
     */

    function match( el, selector ) {
      if ( vendor ) return vendor.call( el, selector );
      var nodes = query.all( selector, el.parentNode );
      for ( var i = 0; i < nodes.length; ++i ) {
        if ( nodes[ i ] == el ) return true;
      }
      return false;
    }

  } );
  require.register( "discore-closest/index.js", function( exports, require, module ) {
    var matches = require( 'matches-selector' )

    module.exports = function( element, selector, checkYoSelf, root ) {
      element = checkYoSelf ? {
        parentNode: element
      } : element

      root = root || document

      // Make sure `element !== document` and `element != null`
      // otherwise we get an illegal invocation
      while ( ( element = element.parentNode ) && element !== document ) {
        if ( matches( element, selector ) )
          return element
        // After `matches` on the edge case that
        // the selector matches the root
        // (when the root is not the document)
        if ( element === root )
          return
      }
    }
  } );
  require.register( "component-delegate/index.js", function( exports, require, module ) {
    /**
     * Module dependencies.
     */

    var closest = require( 'closest' ),
      event = require( 'event' );

    /**
     * Delegate event `type` to `selector`
     * and invoke `fn(e)`. A callback function
     * is returned which may be passed to `.unbind()`.
     *
     * @param {Element} el
     * @param {String} selector
     * @param {String} type
     * @param {Function} fn
     * @param {Boolean} capture
     * @return {Function}
     * @api public
     */

    exports.bind = function( el, selector, type, fn, capture ) {
      return event.bind( el, type, function( e ) {
        var target = e.target || e.srcElement;
        e.delegateTarget = closest( target, selector, true, el );
        if ( e.delegateTarget ) fn.call( el, e );
      }, capture );
    };

    /**
     * Unbind event `type`'s callback `fn`.
     *
     * @param {Element} el
     * @param {String} type
     * @param {Function} fn
     * @param {Boolean} capture
     * @api public
     */

    exports.unbind = function( el, type, fn, capture ) {
      event.unbind( el, type, fn, capture );
    };

  } );
  require.register( "component-events/index.js", function( exports, require, module ) {

    /**
     * Module dependencies.
     */

    var events = require( 'event' );
    var delegate = require( 'delegate' );

    /**
     * Expose `Events`.
     */

    module.exports = Events;

    /**
     * Initialize an `Events` with the given
     * `el` object which events will be bound to,
     * and the `obj` which will receive method calls.
     *
     * @param {Object} el
     * @param {Object} obj
     * @api public
     */

    function Events( el, obj ) {
      if ( !( this instanceof Events ) ) return new Events( el, obj );
      if ( !el ) throw new Error( 'element required' );
      if ( !obj ) throw new Error( 'object required' );
      this.el = el;
      this.obj = obj;
      this._events = {};
    }

    /**
     * Subscription helper.
     */

    Events.prototype.sub = function( event, method, cb ) {
      this._events[ event ] = this._events[ event ] || {};
      this._events[ event ][ method ] = cb;
    };

    /**
     * Bind to `event` with optional `method` name.
     * When `method` is undefined it becomes `event`
     * with the "on" prefix.
     *
     * Examples:
     *
     *  Direct event handling:
     *
     *    events.bind('click') // implies "onclick"
     *    events.bind('click', 'remove')
     *    events.bind('click', 'sort', 'asc')
     *
     *  Delegated event handling:
     *
     *    events.bind('click li > a')
     *    events.bind('click li > a', 'remove')
     *    events.bind('click a.sort-ascending', 'sort', 'asc')
     *    events.bind('click a.sort-descending', 'sort', 'desc')
     *
     * @param {String} event
     * @param {String|function} [method]
     * @return {Function} callback
     * @api public
     */

    Events.prototype.bind = function( event, method ) {
      var e = parse( event );
      var el = this.el;
      var obj = this.obj;
      var name = e.name;
      var method = method || 'on' + name;
      var args = [].slice.call( arguments, 2 );

      // callback
      function cb() {
        var a = [].slice.call( arguments ).concat( args );
        obj[ method ].apply( obj, a );
      }

      // bind
      if ( e.selector ) {
        cb = delegate.bind( el, e.selector, name, cb );
      } else {
        events.bind( el, name, cb );
      }

      // subscription for unbinding
      this.sub( name, method, cb );

      return cb;
    };

    /**
     * Unbind a single binding, all bindings for `event`,
     * or all bindings within the manager.
     *
     * Examples:
     *
     *  Unbind direct handlers:
     *
     *     events.unbind('click', 'remove')
     *     events.unbind('click')
     *     events.unbind()
     *
     * Unbind delegate handlers:
     *
     *     events.unbind('click', 'remove')
     *     events.unbind('click')
     *     events.unbind()
     *
     * @param {String|Function} [event]
     * @param {String|Function} [method]
     * @api public
     */

    Events.prototype.unbind = function( event, method ) {
      if ( 0 == arguments.length ) return this.unbindAll();
      if ( 1 == arguments.length ) return this.unbindAllOf( event );

      // no bindings for this event
      var bindings = this._events[ event ];
      if ( !bindings ) return;

      // no bindings for this method
      var cb = bindings[ method ];
      if ( !cb ) return;

      events.unbind( this.el, event, cb );
    };

    /**
     * Unbind all events.
     *
     * @api private
     */

    Events.prototype.unbindAll = function() {
      for ( var event in this._events ) {
        this.unbindAllOf( event );
      }
    };

    /**
     * Unbind all events for `event`.
     *
     * @param {String} event
     * @api private
     */

    Events.prototype.unbindAllOf = function( event ) {
      var bindings = this._events[ event ];
      if ( !bindings ) return;

      for ( var method in bindings ) {
        this.unbind( event, method );
      }
    };

    /**
     * Parse `event`.
     *
     * @param {String} event
     * @return {Object}
     * @api private
     */

    function parse( event ) {
      var parts = event.split( / +/ );
      return {
        name: parts.shift(),
        selector: parts.join( ' ' )
      }
    }

  } );
  require.register( "component-indexof/index.js", function( exports, require, module ) {
    module.exports = function( arr, obj ) {
      if ( arr.indexOf ) return arr.indexOf( obj );
      for ( var i = 0; i < arr.length; ++i ) {
        if ( arr[ i ] === obj ) return i;
      }
      return -1;
    };

  } );
  require.register( "component-classes/index.js", function( exports, require, module ) {
    /**
     * Module dependencies.
     */

    var index = require( 'indexof' );

    /**
     * Whitespace regexp.
     */

    var re = /\s+/;

    /**
     * toString reference.
     */

    var toString = Object.prototype.toString;

    /**
     * Wrap `el` in a `ClassList`.
     *
     * @param {Element} el
     * @return {ClassList}
     * @api public
     */

    module.exports = function( el ) {
      return new ClassList( el );
    };

    /**
     * Initialize a new ClassList for `el`.
     *
     * @param {Element} el
     * @api private
     */

    function ClassList( el ) {
      if ( !el ) throw new Error( 'A DOM element reference is required' );
      this.el = el;
      this.list = el.classList;
    }

    /**
     * Add class `name` if not already present.
     *
     * @param {String} name
     * @return {ClassList}
     * @api public
     */

    ClassList.prototype.add = function( name ) {
      // classList
      if ( this.list ) {
        this.list.add( name );
        return this;
      }

      // fallback
      var arr = this.array();
      var i = index( arr, name );
      if ( !~i ) arr.push( name );
      this.el.className = arr.join( ' ' );
      return this;
    };

    /**
     * Remove class `name` when present, or
     * pass a regular expression to remove
     * any which match.
     *
     * @param {String|RegExp} name
     * @return {ClassList}
     * @api public
     */

    ClassList.prototype.remove = function( name ) {
      if ( '[object RegExp]' == toString.call( name ) ) {
        return this.removeMatching( name );
      }

      // classList
      if ( this.list ) {
        this.list.remove( name );
        return this;
      }

      // fallback
      var arr = this.array();
      var i = index( arr, name );
      if ( ~i ) arr.splice( i, 1 );
      this.el.className = arr.join( ' ' );
      return this;
    };

    /**
     * Remove all classes matching `re`.
     *
     * @param {RegExp} re
     * @return {ClassList}
     * @api private
     */

    ClassList.prototype.removeMatching = function( re ) {
      var arr = this.array();
      for ( var i = 0; i < arr.length; i++ ) {
        if ( re.test( arr[ i ] ) ) {
          this.remove( arr[ i ] );
        }
      }
      return this;
    };

    /**
     * Toggle class `name`, can force state via `force`.
     *
     * For browsers that support classList, but do not support `force` yet,
     * the mistake will be detected and corrected.
     *
     * @param {String} name
     * @param {Boolean} force
     * @return {ClassList}
     * @api public
     */

    ClassList.prototype.toggle = function( name, force ) {
      // classList
      if ( this.list ) {
        if ( "undefined" !== typeof force ) {
          if ( force !== this.list.toggle( name, force ) ) {
            this.list.toggle( name ); // toggle again to correct
          }
        } else {
          this.list.toggle( name );
        }
        return this;
      }

      // fallback
      if ( "undefined" !== typeof force ) {
        if ( !force ) {
          this.remove( name );
        } else {
          this.add( name );
        }
      } else {
        if ( this.has( name ) ) {
          this.remove( name );
        } else {
          this.add( name );
        }
      }

      return this;
    };

    /**
     * Return an array of classes.
     *
     * @return {Array}
     * @api public
     */

    ClassList.prototype.array = function() {
      var str = this.el.className.replace( /^\s+|\s+$/g, '' );
      var arr = str.split( re );
      if ( '' === arr[ 0 ] ) arr.shift();
      return arr;
    };

    /**
     * Check if class `name` is present.
     *
     * @param {String} name
     * @return {ClassList}
     * @api public
     */

    ClassList.prototype.has =
      ClassList.prototype.contains = function( name ) {
        return this.list ?
          this.list.contains( name ) :
          !!~index( this.array(), name );
      };

  } );
  require.register( "component-emitter/index.js", function( exports, require, module ) {

    /**
     * Expose `Emitter`.
     */

    module.exports = Emitter;

    /**
     * Initialize a new `Emitter`.
     *
     * @api public
     */

    function Emitter( obj ) {
      if ( obj ) return mixin( obj );
    };

    /**
     * Mixin the emitter properties.
     *
     * @param {Object} obj
     * @return {Object}
     * @api private
     */

    function mixin( obj ) {
      for ( var key in Emitter.prototype ) {
        obj[ key ] = Emitter.prototype[ key ];
      }
      return obj;
    }

    /**
     * Listen on the given `event` with `fn`.
     *
     * @param {String} event
     * @param {Function} fn
     * @return {Emitter}
     * @api public
     */

    Emitter.prototype.on =
      Emitter.prototype.addEventListener = function( event, fn ) {
        this._callbacks = this._callbacks || {};
        ( this._callbacks[ event ] = this._callbacks[ event ] || [] )
        .push( fn );
        return this;
      };

    /**
     * Adds an `event` listener that will be invoked a single
     * time then automatically removed.
     *
     * @param {String} event
     * @param {Function} fn
     * @return {Emitter}
     * @api public
     */

    Emitter.prototype.once = function( event, fn ) {
      var self = this;
      this._callbacks = this._callbacks || {};

      function on() {
        self.off( event, on );
        fn.apply( this, arguments );
      }

      on.fn = fn;
      this.on( event, on );
      return this;
    };

    /**
     * Remove the given callback for `event` or all
     * registered callbacks.
     *
     * @param {String} event
     * @param {Function} fn
     * @return {Emitter}
     * @api public
     */

    Emitter.prototype.off =
      Emitter.prototype.removeListener =
      Emitter.prototype.removeAllListeners =
      Emitter.prototype.removeEventListener = function( event, fn ) {
        this._callbacks = this._callbacks || {};

        // all
        if ( 0 == arguments.length ) {
          this._callbacks = {};
          return this;
        }

        // specific event
        var callbacks = this._callbacks[ event ];
        if ( !callbacks ) return this;

        // remove all handlers
        if ( 1 == arguments.length ) {
          delete this._callbacks[ event ];
          return this;
        }

        // remove specific handler
        var cb;
        for ( var i = 0; i < callbacks.length; i++ ) {
          cb = callbacks[ i ];
          if ( cb === fn || cb.fn === fn ) {
            callbacks.splice( i, 1 );
            break;
          }
        }
        return this;
      };

    /**
     * Emit `event` with the given args.
     *
     * @param {String} event
     * @param {Mixed} ...
     * @return {Emitter}
     */

    Emitter.prototype.emit = function( event ) {
      this._callbacks = this._callbacks || {};
      var args = [].slice.call( arguments, 1 ),
        callbacks = this._callbacks[ event ];

      if ( callbacks ) {
        callbacks = callbacks.slice( 0 );
        for ( var i = 0, len = callbacks.length; i < len; ++i ) {
          callbacks[ i ].apply( this, args );
        }
      }

      return this;
    };

    /**
     * Return array of callbacks for `event`.
     *
     * @param {String} event
     * @return {Array}
     * @api public
     */

    Emitter.prototype.listeners = function( event ) {
      this._callbacks = this._callbacks || {};
      return this._callbacks[ event ] || [];
    };

    /**
     * Check if this emitter has `event` handlers.
     *
     * @param {String} event
     * @return {Boolean}
     * @api public
     */

    Emitter.prototype.hasListeners = function( event ) {
      return !!this.listeners( event ).length;
    };

  } );
  require.register( "ui-component-mouse/index.js", function( exports, require, module ) {

    /**
     * dependencies.
     */

    var emitter = require( 'emitter' ),
      event = require( 'event' );

    /**
     * export `Mouse`
     */

    module.exports = function( el, obj ) {
      return new Mouse( el, obj );
    };

    /**
     * initialize new `Mouse`.
     * 
     * @param {Element} el
     * @param {Object} obj
     */

    function Mouse( el, obj ) {
      this.obj = obj || {};
      this.el = el;
    }

    /**
     * mixin emitter.
     */

    emitter( Mouse.prototype );

    /**
     * bind mouse.
     * 
     * @return {Mouse}
     */

    Mouse.prototype.bind = function() {
      var obj = this.obj,
        self = this;

      // up
      function up( e ) {
        obj.onmouseup && obj.onmouseup( e );
        event.unbind( document, 'mousemove', move );
        event.unbind( document, 'mouseup', up );
        self.emit( 'up', e );
      }

      // move
      function move( e ) {
        obj.onmousemove && obj.onmousemove( e );
        self.emit( 'move', e );
      }

      // down
      self.down = function( e ) {
        obj.onmousedown && obj.onmousedown( e );
        event.bind( document, 'mouseup', up );
        event.bind( document, 'mousemove', move );
        self.emit( 'down', e );
      };

      // bind all.
      event.bind( this.el, 'mousedown', self.down );

      return this;
    };

    /**
     * unbind mouse.
     * 
     * @return {Mouse}
     */

    Mouse.prototype.unbind = function() {
      event.unbind( this.el, 'mousedown', this.down );
      this.down = null;
    };

  } );
  require.register( "abpetkov-percentage-calc/percentage-calc.js", function( exports, require, module ) {

    /**
     * Percentage-Calc 0.0.1
     * https://github.com/abpetkov/percentage-calc
     *
     * Authored by Alexander Petkov
     * https://github.com/abpetkov
     *
     * Copyright 2014, Alexander Petkov
     * License: The MIT License (MIT)
     * http://opensource.org/licenses/MIT
     *
     */

    /**
     * Check if number.
     *
     * @param {Number} num
     * @returns {Boolean}
     * @api public
     */

    exports.isNumber = function( num ) {
      return ( typeof num === 'number' ) ? true : false;
    };

    /**
     * Calculate percentage of a number.
     *
     * @param {Number} perc
     * @param {Number} num
     * @returns {Number} result
     * @api public
     */

    exports.of = function( perc, num ) {
      if ( exports.isNumber( perc ) && exports.isNumber( num ) ) return ( perc / 100 ) * num;
    };

    /**
     * Calculate percentage of a number out ot another number.
     *
     * @param {Number} part
     * @param {Number} target
     * @returns {Number} result
     * @api public
     */

    exports.from = function( part, target ) {
      if ( exports.isNumber( part ) && exports.isNumber( target ) ) return ( part / target ) * 100;
    };
  } );
  require.register( "abpetkov-closest-num/closest-num.js", function( exports, require, module ) {
    /**
     * Closest-num 0.0.1
     * https://github.com/abpetkov/closest-num
     *
     * Author: Alexander Petkov
     * https://github.com/abpetkov
     *
     * Copyright 2014, Alexander Petkov
     * License: The MIT License (MIT)
     * http://opensource.org/licenses/MIT
     *
     */

    /**
     * Get closest number in array.
     *
     * @param {Number} target
     * @param {Array} points
     * @returns {Number} closest
     * @api private
     */

    exports.find = function( target, points ) {
      var diff = null,
        current = null,
        closest = points[ 0 ];

      for ( i = 0; i < points.length; i++ ) {
        diff = Math.abs( target - closest );
        current = Math.abs( target - points[ i ] );
        if ( current < diff ) closest = points[ i ];
      }

      return closest;
    };
  } );
  require.register( "vesln-super/lib/super.js", function( exports, require, module ) {
    /**
     * slice
     */

    var slice = Array.prototype.slice;

    /**
     * Primary export
     */

    var exports = module.exports = super_;

    /**
     * ### _super (dest, orig)
     *
     * Inherits the prototype methods or merges objects.
     * This is the primary export and it is recommended
     * that it be imported as `inherits` in node to match
     * the auto imported browser interface.
     *
     *     var inherits = require('super');
     *
     * @param {Object|Function} destination object
     * @param {Object|Function} source object
     * @name _super
     * @api public
     */

    function super_() {
      var args = slice.call( arguments );
      if ( !args.length ) return;
      if ( typeof args[ 0 ] !== 'function' ) return exports.merge( args );
      exports.inherits.apply( null, args );
    };

    /**
     * ### extend (proto[, klass])
     *
     * Provide `.extend` mechanism to allow extenion without
     * needing to use dependancy.
     *
     *     function Bar () {
     *       this._konstructed = true;
     *     }
     *
     *     Bar.extend = inherits.extend;
     *
     *     var Fu = Bar.extend({
     *       initialize: function () {
     *         this._initialized = true;
     *       }
     *     });
     *
     *     var fu = new Fu();
     *     fu.should.be.instanceof(Fu); // true
     *     fu.should.be.instanceof(Bar); // true
     *
     * @param {Object} properties/methods to add to new prototype
     * @param {Object} properties/methods to add to new class
     * @returns {Object} new constructor
     * @name extend
     * @api public
     */

    exports.extend = function( proto, klass ) {
      var self = this,
        child = function() {
          return self.apply( this, arguments );
        };
      exports.merge( [ child, this ] );
      exports.inherits( child, this );
      if ( proto ) exports.merge( [ child.prototype, proto ] );
      if ( klass ) exports.merge( [ child, klass ] );
      child.extend = this.extend; // prevent overwrite
      return child;
    };

    /**
     * ### inherits (ctor, superCtor)
     *
     * Inherit the prototype methods from on contructor
     * to another.
     *
     * @param {Function} destination
     * @param {Function} source
     * @api private
     */

    exports.inherits = function( ctor, superCtor ) {
      ctor.super_ = superCtor;
      if ( Object.create ) {
        ctor.prototype = Object.create( superCtor.prototype, {
          constructor: {
            value: ctor,
            enumerable: false,
            writable: true,
            configurable: true
          }
        } );
      } else {
        ctor.prototype = new superCtor();
        ctor.prototype.constructor = ctor;
      }
    }

    /**
     * Extends multiple objects.
     *
     * @param {Array} array of objects
     * @api private
     */

    exports.merge = function( arr ) {
      var main = arr.length === 2 ? arr.shift() : {};
      var obj = null;

      for ( var i = 0, len = arr.length; i < len; i++ ) {
        obj = arr[ i ];
        for ( var p in obj ) {
          if ( !obj.hasOwnProperty( p ) ) continue;
          main[ p ] = obj[ p ];
        }
      }

      return main;
    };

  } );
  require.register( "powerange/lib/powerange.js", function( exports, require, module ) {
    /**
     * Require classes.
     */

    var Main = require( './main' ),
      Horizontal = require( './horizontal' ),
      Vertical = require( './vertical' );
    
    /**
     * Set default values.
     *
     * @api public
     */

    var defaults = {
      callback: function() {},
      decimal: false,
      disable: false,
      disableOpacity: 0.5,
      hideRange: false,
      klass: '',
      min: 0,
      max: 100,
      start: null,
      step: null,
      vertical: false
    };

    /**
     * Expose proper type of `Powerange`.
     */

    module.exports = function( element, options ) {
      options = options || {};

      for ( var i in defaults ) {
        if ( options[ i ] == null ) {
          options[ i ] = defaults[ i ];
        }
      }

      if ( options.vertical ) {
        return new Vertical( element, options );
      } else {
        return new Horizontal( element, options );
      }
    };
  } );
  require.register( "powerange/lib/main.js", function( exports, require, module ) {
    /**
     * External dependencies.
     *
     */

    var mouse = require( 'mouse' ),
      events = require( 'events' ),
      classes = require( 'classes' ),
      percentage = require( 'percentage-calc' );

    /**
     * Expose `Powerange`.
     */

    module.exports = Powerange;

    /**
     * Create Powerange object.
     *
     * @constructor
     * @param {Object} element
     * @param {Object} options
     * @api public
     */

    function Powerange( element, options ) {
      if ( !( this instanceof Powerange ) ) return new Powerange( element, options );

      this.element = element;
      this.options = options || {};
      this.slider = this.create( 'span', 'range-bar' );

      if ( this.element !== null && this.element.type !== 'text' ) this.init();
    }

    /**
     * Bind events on handle element.
     *
     * @api private
     */

    Powerange.prototype.bindEvents = function() {
      this.handle = this.slider.querySelector( '.range-handle' );
      this.touch = events( this.handle, this );
      this.touch.bind( 'touchstart', 'onmousedown' );
      this.touch.bind( 'touchmove', 'onmousemove' );
      this.touch.bind( 'touchend', 'onmouseup' );
      this.mouse = mouse( this.handle, this );
      this.mouse.bind();
    };

    /**
     * Hide the target element.
     *
     * @api private
     */

    Powerange.prototype.hide = function() {
      this.element.style.display = 'none';
    };

    /**
     * Append the target after the element.
     *
     * @api private
     */

    Powerange.prototype.append = function() {
      var slider = this.generate();
      this.insertAfter( this.element, slider );
    };

    /**
     * Generate the appropriate type of slider.
     *
     * @returns {Object} this.slider
     * @api private
     */

    Powerange.prototype.generate = function() {
      var elems = {
        'handle': {
          'type': 'span',
          'selector': 'range-handle'
        },
        'min': {
          'type': 'span',
          'selector': 'range-min'
        },
        'max': {
          'type': 'span',
          'selector': 'range-max'
        },
        'quantity': {
          'type': 'span',
          'selector': 'range-quantity'
        }
      };

      for ( var key in elems ) {
        if ( elems.hasOwnProperty( key ) ) {
          var temp = this.create( elems[ key ].type, elems[ key ].selector );
          this.slider.appendChild( temp );
        }
      }

      return this.slider;
    };

    /**
     * Create HTML element.
     *
     * @param {String} type
     * @param {String} name
     * @returns {Object} elem
     * @api private
     */

    Powerange.prototype.create = function( type, name ) {
      var elem = document.createElement( type );
      elem.className = name;

      return elem;
    };

    /**
     * Insert element after another element.
     *
     * @param {Object} reference
     * @param {Object} target
     * @api private
     */

    Powerange.prototype.insertAfter = function( reference, target ) {
      reference.parentNode.insertBefore( target, reference.nextSibling );
    };

    /**
     * Add an additional class for extra customization.
     *
     * @param {String} klass
     * @api private
     */

    Powerange.prototype.extraClass = function( klass ) {
      if ( this.options.klass ) classes( this.slider ).add( klass );
    };

    /**
     * Set min and max values.
     *
     * @param {Number} min
     * @param {Number} max
     * @api private
     */

    Powerange.prototype.setRange = function( min, max ) {
      if ( typeof min === 'number' && typeof max === 'number' && !this.options.hideRange ) {
        this.slider.querySelector( '.range-min' ).innerHTML = min;
        this.slider.querySelector( '.range-max' ).innerHTML = max;
      }
    };

    /**
     * Set slider current value.
     *
     * @param {Number} offset
     * @param {Number} size
     * @api private
     */

    Powerange.prototype.setValue = function( offset, size ) {
      var part = percentage.from( parseFloat( offset ), size ),
        value = percentage.of( part, this.options.max - this.options.min ) + this.options.min,
        changed = false;

      value = ( this.options.decimal ) ? ( Math.round( value * 100 ) / 100 ) : Math.round( value );
      changed = ( this.element.value != value ) ? true : false;

      this.element.value = value;
      this.options.callback();
      if ( changed ) this.changeEvent();
    };

    /**
     * Set step.
     *
     * @param {Number} sliderSize
     * @param {Number} handleSize
     * @returns {Array} this.steps
     * @api private
     */

    Powerange.prototype.step = function( sliderSize, handleSize ) {
      var dimension = sliderSize - handleSize,
        part = percentage.from( this.checkStep( this.options.step ), this.options.max - this.options.min ),
        interval = percentage.of( part, dimension ),
        steps = [];

      for ( i = 0; i <= dimension; i += interval ) {
        steps.push( i );
      }

      this.steps = steps;

      return this.steps;
    };

    /**
     * Check values.
     *
     * @param {Number} start
     * @api private
     */

    Powerange.prototype.checkValues = function( start ) {
      if ( start < this.options.min ) this.options.start = this.options.min;
      if ( start > this.options.max ) this.options.start = this.options.max;
      if ( this.options.min >= this.options.max ) this.options.min = this.options.max;
    };

    /**
     * Make sure `step` is positive.
     *
     * @param {Number} value
     * @returns {Number} this.options.step
     * @api private
     */

    Powerange.prototype.checkStep = function( value ) {
      if ( value < 0 ) value = Math.abs( value );
      this.options.step = value;
      return this.options.step;
    };

    /**
     * Disable range slider.
     *
     * @api private
     */

    Powerange.prototype.disable = function() {
      if ( this.options.min == this.options.max || this.options.min > this.options.max || this.options.disable ) {
        this.mouse.unbind();
        this.touch.unbind();
        this.slider.style.opacity = this.options.disableOpacity;
        classes( this.handle ).add( 'range-disabled' );
      }
    };

    /**
     * Make element unselectable.
     *
     * @param {Object} element
     * @param {Boolean} set
     * @api private
     */

    Powerange.prototype.unselectable = function( element, set ) {
      if ( !classes( this.slider ).has( 'unselectable' ) && set === true ) {
        classes( this.slider ).add( 'unselectable' );
      } else {
        classes( this.slider ).remove( 'unselectable' );
      }
    };

    /**
     * Handle the onchange event.
     *
     * @param {Boolean} state
     * @api private
     */

    Powerange.prototype.changeEvent = function( state ) {
      if ( typeof Event === 'function' || !document.fireEvent ) {
        var event = document.createEvent( 'HTMLEvents' );
        event.initEvent( 'change', false, true );
        this.element.dispatchEvent( event );
      } else {
        this.element.fireEvent( 'onchange' );
      }
    };

    /**
     * Initialize main class.
     *
     * @api private
     */

    Powerange.prototype.init = function() {
      this.hide();
      this.append();
      this.bindEvents();
      this.extraClass( this.options.klass );
      this.checkValues( this.options.start );
      this.setRange( this.options.min, this.options.max );
      this.disable();
    };
  } );
  require.register( "powerange/lib/horizontal.js", function( exports, require, module ) {
    /**
     * External dependencies.
     *
     */

    var inherits = require( 'super' ),
      closest = require( 'closest-num' ),
      percentage = require( 'percentage-calc' );

    /**
     * Require main class.
     */

    var Powerange = require( './main' );

    /**
     * Expose `Horizontal`.
     */

    module.exports = Horizontal;

    /**
     * Create horizontal slider object.
     *
     * @api public
     */

    function Horizontal() {
      Powerange.apply( this, arguments );
      if ( this.options.step ) this.step( this.slider.offsetWidth, this.handle.offsetWidth );
      this.setStart( this.options.start );
    }

    /**
     * Inherit the main class.
     */

    inherits( Horizontal, Powerange );

    /**
     * Set horizontal slider position.
     *
     * @param {Number} start
     * @api private
     */

    Horizontal.prototype.setStart = function( start ) {
      var begin = ( start === null ) ? this.options.min : start,
        part = percentage.from( begin - this.options.min, this.options.max - this.options.min ) || 0,
        offset = percentage.of( part, this.slider.offsetWidth - this.handle.offsetWidth ),
        position = ( this.options.step ) ? closest.find( offset, this.steps ) : offset;

      this.setPosition( position );
      this.setValue( this.handle.style.left, this.slider.offsetWidth - this.handle.offsetWidth );
    };

    /**
     * Set horizontal slider current position.
     *
     * @param {Number} val
     * @api private
     */

    Horizontal.prototype.setPosition = function( val ) {
      this.handle.style.left = val + 'px';
      this.slider.querySelector( '.range-quantity' ).style.width = val + 'px';
    };

    /**
     * On slider mouse down.
     *
     * @param {Object} e
     * @api private
     */

    Horizontal.prototype.onmousedown = function( e ) {
      if ( e.touches ) e = e.touches[ 0 ];
      this.startX = e.clientX;
      this.handleOffsetX = this.handle.offsetLeft;
      this.restrictHandleX = this.slider.offsetWidth - this.handle.offsetWidth;
      this.unselectable( this.slider, true );
    };

    /**
     * On slider mouse move.
     *
     * @param {Object} e
     * @api private
     */

    Horizontal.prototype.onmousemove = function( e ) {
      e.preventDefault();
      if ( e.touches ) e = e.touches[ 0 ];

      var leftOffset = this.handleOffsetX + e.clientX - this.startX,
        position = ( this.steps ) ? closest.find( leftOffset, this.steps ) : leftOffset;

      if ( leftOffset <= 0 ) {
        this.setPosition( 0 );
      } else if ( leftOffset >= this.restrictHandleX ) {
        this.setPosition( this.restrictHandleX );
      } else {
        this.setPosition( position );
      }

      this.setValue( this.handle.style.left, this.slider.offsetWidth - this.handle.offsetWidth );
    };

    /**
     * On mouse up.
     *
     * @param {Object} e
     * @api private
     */

    Horizontal.prototype.onmouseup = function( e ) {
      this.unselectable( this.slider, false );
    };
  } );
  require.register( "powerange/lib/vertical.js", function( exports, require, module ) {
    /**
     * External dependencies.
     *
     */

    var inherits = require( 'super' ),
      classes = require( 'classes' ),
      closest = require( 'closest-num' ),
      percentage = require( 'percentage-calc' );

    /**
     * Require main class.
     */

    var Powerange = require( './main' );

    /**
     * Expose `Vertical`.
     */

    module.exports = Vertical;

    /**
     * Create vertical slider object.
     *
     * @api public
     */

    function Vertical() {
      Powerange.apply( this, arguments );
      classes( this.slider ).add( 'vertical' );
      if ( this.options.step ) this.step( this.slider.offsetHeight, this.handle.offsetHeight );
      this.setStart( this.options.start );
    }

    /**
     * Inherit the main class.
     */

    inherits( Vertical, Powerange );

    /**
     * Set vertical slider position.
     *
     * @param {Number} start
     * @api private
     */

    Vertical.prototype.setStart = function( start ) {
      var begin = ( start === null ) ? this.options.min : start,
        part = percentage.from( begin - this.options.min, this.options.max - this.options.min ) || 0,
        offset = percentage.of( part, this.slider.offsetHeight - this.handle.offsetHeight ),
        position = ( this.options.step ) ? closest.find( offset, this.steps ) : offset;

      this.setPosition( position );
      this.setValue( this.handle.style.bottom, this.slider.offsetHeight - this.handle.offsetHeight );
    };

    /**
     * Set vertical slider current position.
     *
     * @param {Number} val
     * @api private
     */

    Vertical.prototype.setPosition = function( val ) {
      this.handle.style.bottom = val + 'px';
      this.slider.querySelector( '.range-quantity' ).style.height = val + 'px';
    };

    /**
     * On mouse down.
     *
     * @param {Object} e
     * @api private
     */

    Vertical.prototype.onmousedown = function( e ) {
      if ( e.touches ) e = e.touches[ 0 ];
      this.startY = e.clientY;
      this.handleOffsetY = this.slider.offsetHeight - this.handle.offsetHeight - this.handle.offsetTop;
      this.restrictHandleY = this.slider.offsetHeight - this.handle.offsetHeight;
      this.unselectable( this.slider, true );
    };

    /**
     * On vertical slider mouse move.
     *
     * @param {Object} e
     * @api private
     */

    Vertical.prototype.onmousemove = function( e ) {
      e.preventDefault();
      if ( e.touches ) e = e.touches[ 0 ];

      var bottomOffset = this.handleOffsetY + this.startY - e.clientY,
        position = ( this.steps ) ? closest.find( bottomOffset, this.steps ) : bottomOffset;

      if ( bottomOffset <= 0 ) {
        this.setPosition( 0 );
      } else if ( bottomOffset >= this.restrictHandleY ) {
        this.setPosition( this.restrictHandleY );
      } else {
        this.setPosition( position );
      }

      this.setValue( this.handle.style.bottom, this.slider.offsetHeight - this.handle.offsetHeight );
    };

    /**
     * On mouse up.
     *
     * @param {Object} e
     * @api private
     */

    Vertical.prototype.onmouseup = function( e ) {
      this.unselectable( this.slider, false );
    };
  } );














  require.alias( "component-events/index.js", "powerange/deps/events/index.js" );
  require.alias( "component-events/index.js", "events/index.js" );
  require.alias( "component-event/index.js", "component-events/deps/event/index.js" );

  require.alias( "component-delegate/index.js", "component-events/deps/delegate/index.js" );
  require.alias( "discore-closest/index.js", "component-delegate/deps/closest/index.js" );
  require.alias( "discore-closest/index.js", "component-delegate/deps/closest/index.js" );
  require.alias( "component-matches-selector/index.js", "discore-closest/deps/matches-selector/index.js" );
  require.alias( "component-query/index.js", "component-matches-selector/deps/query/index.js" );

  require.alias( "discore-closest/index.js", "discore-closest/index.js" );
  require.alias( "component-event/index.js", "component-delegate/deps/event/index.js" );

  require.alias( "component-classes/index.js", "powerange/deps/classes/index.js" );
  require.alias( "component-classes/index.js", "classes/index.js" );
  require.alias( "component-indexof/index.js", "component-classes/deps/indexof/index.js" );

  require.alias( "ui-component-mouse/index.js", "powerange/deps/mouse/index.js" );
  require.alias( "ui-component-mouse/index.js", "mouse/index.js" );
  require.alias( "component-emitter/index.js", "ui-component-mouse/deps/emitter/index.js" );

  require.alias( "component-event/index.js", "ui-component-mouse/deps/event/index.js" );

  require.alias( "abpetkov-percentage-calc/percentage-calc.js", "powerange/deps/percentage-calc/percentage-calc.js" );
  require.alias( "abpetkov-percentage-calc/percentage-calc.js", "powerange/deps/percentage-calc/index.js" );
  require.alias( "abpetkov-percentage-calc/percentage-calc.js", "percentage-calc/index.js" );
  require.alias( "abpetkov-percentage-calc/percentage-calc.js", "abpetkov-percentage-calc/index.js" );
  require.alias( "abpetkov-closest-num/closest-num.js", "powerange/deps/closest-num/closest-num.js" );
  require.alias( "abpetkov-closest-num/closest-num.js", "powerange/deps/closest-num/index.js" );
  require.alias( "abpetkov-closest-num/closest-num.js", "closest-num/index.js" );
  require.alias( "abpetkov-closest-num/closest-num.js", "abpetkov-closest-num/index.js" );
  require.alias( "vesln-super/lib/super.js", "powerange/deps/super/lib/super.js" );
  require.alias( "vesln-super/lib/super.js", "powerange/deps/super/index.js" );
  require.alias( "vesln-super/lib/super.js", "super/index.js" );
  require.alias( "vesln-super/lib/super.js", "vesln-super/index.js" );
  require.alias( "powerange/lib/powerange.js", "powerange/index.js" );
  if ( typeof exports == "object" ) {
    module.exports = require( "powerange" );
  } else if ( typeof define == "function" && define.amd ) {
    define( [], function() {
      return require( "powerange" );
    } );
  } else {
    this[ "Powerange" ] = require( "powerange" );
  }
} )();
